home *** CD-ROM | disk | FTP | other *** search
/ Sprite 1984 - 1993 / Sprite 1984 - 1993.iso / src / cmds / pmake / customs / logd.c < prev    next >
Encoding:
C/C++ Source or Header  |  1989-11-15  |  13.4 KB  |  586 lines
  1. /*-
  2.  * logd.c --
  3.  *    A program to get usage info from all customs agents and
  4.  *    log them in a file in a nice manner.
  5.  *
  6.  * Copyright (c) 1988, 1989 by the Regents of the University of California
  7.  * Copyright (c) 1988, 1989 by Adam de Boor
  8.  * Copyright (c) 1989 by Berkeley Softworks
  9.  *
  10.  * Permission to use, copy, modify, and distribute this
  11.  * software and its documentation for any non-commercial purpose
  12.  * and without fee is hereby granted, provided that the above copyright
  13.  * notice appears in all copies.  The University of California,
  14.  * Berkeley Softworks and Adam de Boor make no representations about
  15.  * the suitability of this software for any purpose.  It is provided
  16.  * "as is" without express or implied warranty.
  17.  */
  18. #ifndef lint
  19. static char *rcsid =
  20. "$Id: logd.c,v 1.11 89/11/14 13:46:10 adam Exp $ SPRITE (Berkeley)";
  21. #endif lint
  22.  
  23. #include    "customs.h"
  24. #include    "log.h"
  25. #include    <netdb.h>
  26. #include    <stdio.h>
  27. #include    <sys/time.h>
  28. /*#include    "/usr/include/time.h"*/
  29. #include    <pwd.h>
  30. #include    <sys/wait.h>
  31. #include    <varargs.h>
  32. /*#include    <netinet/in.h>*/
  33. #include    <strings.h>
  34.  
  35. #define LOG_FILE  "/usr/tmp/customs.log"
  36. #define MAXAGENTS 20
  37.  
  38. typedef struct {
  39.     char              *name;
  40.     long              avail;
  41.     long              numClients;
  42.     long        arch;
  43.     long              *clients;
  44.     struct in_addr    addr;
  45. } Agent;
  46.  
  47. Agent       agents[MAXAGENTS];
  48. int              numAgents;
  49.  
  50. typedef struct {
  51.     char          **argv;
  52.     int              id;
  53. } Job;
  54.  
  55. struct sockaddr_in    mca;
  56. Boolean                  force = TRUE;
  57.  
  58. extern int            customs_Socket;
  59. extern struct timeval    customs_RetryTimeOut;
  60.  
  61. FILE                  *logFile;
  62.  
  63. /*-
  64.  *-----------------------------------------------------------------------
  65.  * LogPrintf --
  66.  *
  67.  * Results:
  68.  *
  69.  * Side Effects:
  70.  *
  71.  *-----------------------------------------------------------------------
  72.  */
  73. void
  74. LogPrintf(fmt, va_alist)
  75.     char          *fmt;
  76.     va_dcl
  77. {
  78.     va_list       args;
  79.  
  80.     va_start(args);
  81.     _doprnt(fmt, args, logFile);
  82.     fflush(logFile);
  83. }
  84.  
  85. /*-
  86.  *-----------------------------------------------------------------------
  87.  * LogMark --
  88.  *
  89.  * Results:
  90.  *
  91.  * Side Effects:
  92.  *
  93.  *-----------------------------------------------------------------------
  94.  */
  95. void
  96. LogMark(agent)
  97.     Agent   *agent;
  98. {
  99.     time_t        now;
  100.     struct tm      *curTime;
  101.  
  102.     now = time(0);
  103.     curTime = localtime(&now);
  104.     LogPrintf("%s %2d:%02d:%02d %d/%d -- ",
  105.           agent ? agent->name : "LOG", curTime->tm_hour,
  106.           curTime->tm_min, curTime->tm_sec, curTime->tm_mon + 1,
  107.           curTime->tm_mday);
  108. }
  109. /*-
  110.  *-----------------------------------------------------------------------
  111.  * FindAgent --
  112.  *
  113.  * Results:
  114.  *
  115.  * Side Effects:
  116.  *
  117.  *-----------------------------------------------------------------------
  118.  */
  119. Agent *
  120. FindAgent(addr)
  121.     struct in_addr    addr;
  122. {
  123.     register int i;
  124.  
  125.     for (i = 0; i < numAgents; i++) {
  126.     if (agents[i].addr.s_addr == addr.s_addr) {
  127.         return (&agents[i]);
  128.     }
  129.     }
  130.     return((Agent *)NULL);
  131. }
  132. /*-
  133.  *-----------------------------------------------------------------------
  134.  * Start --
  135.  *    Note starting of a job somewhere.
  136.  *
  137.  * Results:
  138.  *
  139.  * Side Effects:
  140.  *
  141.  *-----------------------------------------------------------------------
  142.  */
  143. void
  144. Start (from, msg, len, data)
  145.     struct sockaddr_in    *from;
  146.     Rpc_Message          msg;
  147.     int                  len;
  148.     char              *data;
  149. {
  150.     XDR                  xdr;
  151.     ExportPermit      permit;
  152.     short             euid, ruid;
  153.     char              **argv;
  154.     struct passwd     *pwd;
  155.  
  156.     xdrmem_create(&xdr, data, len, XDR_DECODE);
  157.     argv = (char **)NULL;
  158.  
  159.     if (xdr_exportpermit(&xdr, &permit) &&
  160.     xdr_short(&xdr, &euid) &&
  161.     xdr_short(&xdr, &ruid) &&
  162.     xdr_strvec(&xdr, &argv)) {
  163.         Agent      *ad, *as;
  164.         int          i;
  165.  
  166.         ad = FindAgent(from->sin_addr);
  167.         as = FindAgent(permit.addr);
  168.         LogMark(ad);
  169.         pwd = getpwuid(euid);
  170.         LogPrintf("#%u ", permit.id);
  171.         if (pwd != (struct passwd *)NULL) {
  172.         LogPrintf("from %s@%s: ", pwd->pw_name, as->name);
  173.         } else {
  174.         LogPrintf("from %d@%s: ", euid, as->name);
  175.         }
  176.         for (i = 0; argv[i]; i++) {
  177.         LogPrintf("%s ", argv[i]);
  178.         }
  179.         LogPrintf("\n");
  180.     }
  181.     Rpc_Return(msg, 0, (Rpc_Opaque)0);
  182. }
  183.  
  184. /*-
  185.  *-----------------------------------------------------------------------
  186.  * Finish --
  187.  *
  188.  * Results:
  189.  *
  190.  * Side Effects:
  191.  *
  192.  *-----------------------------------------------------------------------
  193.  */
  194. void
  195. Finish (from, msg, len, data)
  196.     struct sockaddr_in    *from;
  197.     Rpc_Message          msg;
  198.     int                  len;
  199.     char              *data;
  200. {
  201.     union wait       stat;
  202.     ExportPermit  permit;
  203.     XDR              xdr;
  204.     Agent         *a;
  205.     
  206.     a = FindAgent(from->sin_addr);
  207.     
  208.     xdrmem_create(&xdr, data, len, XDR_DECODE);
  209.     if (xdr_exportpermit(&xdr, &permit) &&
  210.     xdr_int(&xdr, &stat)) {
  211.         LogMark(a);
  212.         LogPrintf("#%u finished ", permit.id);
  213.         if (WIFSIGNALED(stat)) {
  214.         LogPrintf ("signal %d\n", stat.w_termsig);
  215.         } else {
  216.         LogPrintf ("exit %d\n", stat.w_retcode);
  217.         }
  218.     } else {
  219.     LogPrintf ("BAD PACKET from %s\n", a->name);
  220.     }
  221.     Rpc_Return(msg, 0, (Rpc_Opaque)0);
  222. }
  223.  
  224. /*-
  225.  *-----------------------------------------------------------------------
  226.  * Stopped --
  227.  *
  228.  * Results:
  229.  *
  230.  * Side Effects:
  231.  *
  232.  *-----------------------------------------------------------------------
  233.  */
  234. /*ARGSUSED*/
  235. void
  236. Stopped(from, msg, len, data)
  237.     struct sockaddr_in  *from;
  238.     Rpc_Message        msg;
  239.     int            len;
  240.     Rpc_Opaque           data;
  241. {
  242.     ExportPermit  permit;
  243.     XDR              xdr;
  244.     Agent         *a;
  245.     
  246.     a = FindAgent(from->sin_addr);
  247.     
  248.     xdrmem_create(&xdr, data, len, XDR_DECODE);
  249.     if (xdr_exportpermit(&xdr, &permit)) {
  250.     LogMark(a);
  251.     LogPrintf("#%u stopped\n", permit.id);
  252.     } else {
  253.     LogPrintf ("BAD PACKET from %s\n", a->name);
  254.     }
  255.     Rpc_Return(msg, 0, (Rpc_Opaque)0);
  256. }
  257. /*-
  258.  *-----------------------------------------------------------------------
  259.  * NewAgent --
  260.  *
  261.  * Results:
  262.  *
  263.  * Side Effects:
  264.  *
  265.  *-----------------------------------------------------------------------
  266.  */
  267. /*ARGSUSED*/
  268. void
  269. NewAgent(from, msg, len, data)
  270.     struct sockaddr_in  *from;
  271.     Rpc_Message        msg;
  272.     int            len;
  273.     char              *data;
  274. {
  275.     struct sockaddr_in    addr;
  276.     XDR                  xdr;
  277.     Agent             *a;
  278.  
  279.     xdrmem_create(&xdr, data, len, XDR_DECODE);
  280.     Rpc_Return(msg, 0, (Rpc_Opaque)0);
  281.     
  282.     if (xdr_sockaddr_in(&xdr, &addr)) {
  283.     a = FindAgent(addr.sin_addr);
  284.     if (a == (Agent *)NULL) {
  285.         struct hostent *he;
  286.         
  287.         a = &agents[numAgents];
  288.         numAgents++;
  289.         a->addr = addr.sin_addr;
  290.         a->numClients = 0;
  291.         he = gethostbyaddr(&addr.sin_addr, sizeof(addr.sin_addr), AF_INET);
  292.         if (he != (struct hostent *)NULL) {
  293.         a->name = (char *)malloc(strlen(he->h_name)+1);
  294.         strcpy(a->name, he->h_name);
  295.         if (index(a->name, '.')) {
  296.             *index(a->name, '.') = '\0';
  297.         }
  298.         } else {
  299.         a->name = "Unknown";
  300.         }
  301.     }
  302.     LogMark(0);
  303.     LogPrintf("Agent %s registered\n", a->name);
  304.     (void) Rpc_Call(customs_Socket, &addr, (Rpc_Proc)CUSTOMS_LOG,
  305.             sizeof(force), (Rpc_Opaque)&force,
  306.             0, (Rpc_Opaque)0,
  307.             CUSTOMS_RETRY, &customs_RetryTimeOut);
  308.     }
  309. }
  310.             
  311. /*-
  312.  *-----------------------------------------------------------------------
  313.  * NewMaster --
  314.  *
  315.  * Results:
  316.  *
  317.  * Side Effects:
  318.  *
  319.  *-----------------------------------------------------------------------
  320.  */
  321. /*ARGSUSED*/
  322. void
  323. NewMaster(from, msg, len, data)
  324.     struct sockaddr_in  *from;
  325.     Rpc_Message        msg;
  326.     int            len;
  327.     char              *data;
  328. {
  329.     struct sockaddr_in    addr;
  330.     XDR                  xdr;
  331.     Agent             *a;
  332.  
  333.     xdrmem_create(&xdr, data, len, XDR_DECODE);
  334.     Rpc_Return(msg, 0, (Rpc_Opaque)0);
  335.     
  336.     a = FindAgent(from->sin_addr);
  337.     LogMark(a);
  338.     LogPrintf("elected master -- %s\n", InetNtoA(from->sin_addr));
  339.     mca = *from;
  340. }
  341. /*-
  342.  *-----------------------------------------------------------------------
  343.  * Evict --
  344.  *
  345.  * Results:
  346.  *
  347.  * Side Effects:
  348.  *
  349.  *-----------------------------------------------------------------------
  350.  */
  351. /*ARGSUSED*/
  352. void
  353. Evict(from, msg, len, data)
  354.     struct sockaddr_in  *from;
  355.     Rpc_Message        msg;
  356.     int            len;
  357.     Rpc_Opaque           data;
  358. {
  359.     Rpc_Return(msg, 0, (Rpc_Opaque)0);
  360. }
  361.  
  362. /*-
  363.  *-----------------------------------------------------------------------
  364.  * Access --
  365.  *
  366.  * Results:
  367.  *
  368.  * Side Effects:
  369.  *
  370.  *-----------------------------------------------------------------------
  371.  */
  372. /*ARGSUSED*/
  373. void
  374. Access(from, msg, len, data)
  375.     struct sockaddr_in  *from;
  376.     Rpc_Message        msg;
  377.     int            len;
  378.     char              *data;
  379. {
  380.     struct sockaddr_in    addr;
  381.     XDR                  xdr;
  382.     char              fromname[32];
  383.  
  384.     xdrmem_create(&xdr, data, len, XDR_DECODE);
  385.     Rpc_Return(msg, 0, (Rpc_Opaque)0);
  386.     
  387.     if (xdr_sockaddr_in(&xdr, &addr)) {
  388.     LogMark(0);
  389.     LogPrintf("illegal access to %s attempted from %s\n",
  390.           strcpy(fromname, InetNtoA(from->sin_addr)),
  391.           InetNtoA(addr.sin_addr));
  392.     }
  393. }
  394.  
  395. /*-
  396.  *-----------------------------------------------------------------------
  397.  * Killed --
  398.  *
  399.  * Results:
  400.  *
  401.  * Side Effects:
  402.  *
  403.  *-----------------------------------------------------------------------
  404.  */
  405. /*ARGSUSED*/
  406. void
  407. Killed(from, msg, len, data)
  408.     struct sockaddr_in  *from;
  409.     Rpc_Message        msg;
  410.     int            len;
  411.     Rpc_Opaque           data;
  412. {
  413.     ExportPermit  permit;
  414.     long          signo;
  415.     XDR              xdr;
  416.     Agent         *a;
  417.     
  418.     a = FindAgent(from->sin_addr);
  419.     
  420.     xdrmem_create(&xdr, data, len, XDR_DECODE);
  421.     if ((xdr_exportpermit(&xdr, &permit)) &&
  422.     (xdr_long(&xdr, &signo)))
  423.     {
  424.     extern char    *sys_siglist[];
  425.  
  426.     LogMark(a);
  427.     LogPrintf("#%u from %s signaled -- %s\n",
  428.           permit.id,
  429.           InetNtoA(permit.addr),
  430.           sys_siglist[signo]);
  431.     } else {
  432.     LogPrintf ("BAD PACKET from %s\n", a->name);
  433.     }
  434.     Rpc_Return(msg, 0, (Rpc_Opaque)0);
  435. }
  436.  
  437. /*-
  438.  *-----------------------------------------------------------------------
  439.  * ExitFailed --
  440.  *
  441.  * Results:
  442.  *
  443.  * Side Effects:
  444.  *
  445.  *-----------------------------------------------------------------------
  446.  */
  447. /*ARGSUSED*/
  448. void
  449. ExitFailed(from, msg, len, data)
  450.     struct sockaddr_in  *from;
  451.     Rpc_Message        msg;
  452.     int            len;
  453.     Rpc_Opaque           data;
  454. {
  455.     ExportPermit  permit;
  456.     XDR              xdr;
  457.     Agent         *a;
  458.     
  459.     a = FindAgent(from->sin_addr);
  460.     
  461.     xdrmem_create(&xdr, data, len, XDR_DECODE);
  462.     if (xdr_exportpermit(&xdr, &permit)) {
  463.     LogMark(a);
  464.     LogPrintf("#%u from %s: couldn't send EXIT\n",
  465.           permit.id,
  466.           InetNtoA(permit.addr));
  467.     } else {
  468.     LogPrintf ("BAD PACKET from %s\n", a->name);
  469.     }
  470.     Rpc_Return(msg, 0, (Rpc_Opaque)0);
  471. }
  472.  
  473. /*-
  474.  *-----------------------------------------------------------------------
  475.  * main --
  476.  *
  477.  * Results:
  478.  *
  479.  * Side Effects:
  480.  *
  481.  *-----------------------------------------------------------------------
  482.  */
  483. main(argc, argv)
  484.     int        argc;
  485.     char    **argv;
  486. {
  487.     char              infoBuf[MAX_INFO_SIZE];
  488.     int                  i, j;
  489.     char              *cp;
  490.     struct sockaddr_in    sin;
  491.     struct hostent    *he;
  492.     int                  sock;
  493.     extern struct sockaddr_in customs_AgentAddr;
  494.  
  495.     if (Customs_Master(&mca) != RPC_SUCCESS) {
  496.     Customs_PError("Customs_Master");
  497.     printf("Couldn't find master\n");
  498.     exit(1);
  499.     }
  500.     
  501.     if (Customs_Info(&mca, infoBuf) != RPC_SUCCESS) {
  502.     Customs_PError("Customs_Info");
  503.     printf("Couldn't read registration info\n");
  504.     }
  505.  
  506.     if (argc != 2) {
  507.     logFile = fopen (LOG_FILE, "a");
  508.     } else if (strcmp(argv[1], "-") != 0) {
  509.     logFile = fopen (argv[1], "a");
  510.     } else {
  511.     logFile = stdout;
  512.     }
  513.     
  514.     if (logFile == (FILE *)NULL) {
  515.     printf ("Couldn't open log file\n");
  516.     exit(1);
  517.     }
  518.  
  519.     sin.sin_family = AF_INET;
  520.     sin.sin_port = customs_AgentAddr.sin_port;
  521.  
  522.     Rpc_ServerCreate(customs_Socket, (Rpc_Proc)LOG_START, Start,
  523.              Rpc_SwapNull, Rpc_SwapNull, (Rpc_Opaque)0);
  524.     Rpc_ServerCreate(customs_Socket, (Rpc_Proc)LOG_FINISH, Finish,
  525.              Rpc_SwapNull, Rpc_SwapNull, (Rpc_Opaque)0);
  526.     Rpc_ServerCreate(customs_Socket, (Rpc_Proc)LOG_STOPPED, Stopped,
  527.              Rpc_SwapNull, Rpc_SwapNull, (Rpc_Opaque)0);
  528.     Rpc_ServerCreate(customs_Socket, (Rpc_Proc)LOG_NEWAGENT, NewAgent,
  529.              Rpc_SwapNull, Rpc_SwapNull, (Rpc_Opaque)0);
  530.     Rpc_ServerCreate(customs_Socket, (Rpc_Proc)LOG_NEWMASTER, NewMaster,
  531.              Rpc_SwapNull, Rpc_SwapNull, (Rpc_Opaque)0);
  532.     Rpc_ServerCreate(customs_Socket, (Rpc_Proc)LOG_EVICT, Evict,
  533.              Rpc_SwapNull, Rpc_SwapNull, (Rpc_Opaque)0);
  534.     Rpc_ServerCreate(customs_Socket, (Rpc_Proc)LOG_ACCESS, Access,
  535.              Rpc_SwapNull, Rpc_SwapNull, (Rpc_Opaque)0);
  536.     Rpc_ServerCreate(customs_Socket, (Rpc_Proc)LOG_KILL, Killed,
  537.              Rpc_SwapNull, Rpc_SwapNull, (Rpc_Opaque)0);
  538.     Rpc_ServerCreate(customs_Socket, (Rpc_Proc)LOG_EXITFAIL, ExitFailed,
  539.              Rpc_SwapNull, Rpc_SwapNull, (Rpc_Opaque)0);
  540.     
  541.     LogMark(0);
  542.     cp = infoBuf;
  543.     numAgents = *(int *)cp;
  544.     LogPrintf("%d hosts registered:\n", numAgents);
  545.     cp += sizeof(int);
  546.     for (i = 0; i < numAgents; i++) {
  547.     agents[i].name = cp;
  548.     cp += strlen(cp) + 1;
  549.     if (index(agents[i].name, '.')) {
  550.         *index(agents[i].name, '.') = '\0';
  551.     }
  552.     LogPrintf("\t%s: ", agents[i].name);
  553.     cp = Customs_Align(cp, char *);
  554.  
  555.     agents[i].avail = *(long *)cp;
  556.     cp += sizeof(long);
  557.  
  558.     agents[i].arch = *(long *)cp;
  559.     cp += sizeof(long);
  560.  
  561.     agents[i].numClients = *(long *)cp;
  562.     cp += sizeof(long);
  563.  
  564.     agents[i].clients = (long *)cp;
  565.     cp += agents[i].numClients * sizeof(long);
  566.  
  567.     he = gethostbyname(agents[i].name);
  568.     agents[i].addr = *(struct in_addr *)he->h_addr;
  569.     sin.sin_addr = agents[i].addr;
  570.     if (agents[i].avail & AVAIL_DOWN) {
  571.         LogPrintf("marked down\n");
  572.     } else if (Rpc_Call(customs_Socket, &sin, (Rpc_Proc)CUSTOMS_LOG,
  573.              sizeof(force), (Rpc_Opaque)&force,
  574.              0, (Rpc_Opaque)0,
  575.              CUSTOMS_RETRY, &customs_RetryTimeOut) != RPC_SUCCESS)
  576.     {
  577.         LogPrintf("couldn't contact.\n");
  578.     } else {
  579.         LogPrintf("registered\n");
  580.     }
  581.              
  582.     }
  583.     Rpc_Run();
  584. }
  585.  
  586.